package com.agile.springboot.controller;

import com.agile.springboot.common.Result;
import com.agile.springboot.entity.User;
import com.agile.springboot.service.*;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/user")
public class UserController {

    @Resource
    UserService userService;
    @Resource
    LoginService loginService;
    @Resource
    GroupService groupService;
    @Resource
    QuestionnaireService questionnaireService;
    @Resource
    QuestionAnsweredService questionAnsweredService;

    /**
     * 新增用户
     * @param user 信息尽可能完整
     * @return 结果相关信息
     */
    @PostMapping("/addUser")
    public Result<?> addUser(@RequestBody User user){
        List<User> userList1 = loginService.searchUserByUsername(user);//检测用户所填用户名是否已被使用，返回相同用户名的用户
        if (!userList1.isEmpty()) return Result.error("-1","添加用户失败，该用户名已存在");
        List<User> userList2 = loginService.phoneUser(user);//检测用户所填手机号是否已被使用，返回相同手机号的用户
        if (!userList2.isEmpty()) return Result.error("-2","添加用户失败，该电话号码已被使用");
        if(userService.addUser(user)==1){
            return Result.success(user, "添加用户成功");
        }
        return Result.error("-3","添加用户失败");
    }

    /**
     * 逻辑删除用户
     * @param user
     * 所必须的参数为 id 属性
     * @return 结果相关信息
     */
    @PostMapping("/deleteUser")
    public Result<?> deleteUser(@RequestBody User user){
        User the_user = userService.searchUserById(user.getId());
        if(the_user==null){
            return Result.error("0","不存在此用户id!");
        }
        switch (the_user.getIdentity()){
            case 1:
                //如果该租户下不存在用户，即该租户无数据关联，则允许将其删除
                if(userService.queryChildrenCreatedByParent(the_user.getId()).size()==0){//查询当前租户创建的所有用户
                    //删除租户
                    if(userService.deleteUser(user.getId())==1){
                        return Result.success(the_user.getId(), "删除租户成功");
                    }
                }else{
                    return Result.error("-1","删除租户失败,该租户存在关联数据,因为该租户下存在用户!");
                }
                break;
            case 2:
                //如果该用户下不存在答者、群组、问卷，即该用户无数据关联，则允许将其删除
                if(userService.queryChildrenCreatedByParent(the_user.getId()).size()==0&&//查询当前用户创建的所有答者
                   groupService.queryGroupsCreatedByUser(the_user.getId()).size()==0&&//查询当前用户创建的所有群组
                   questionnaireService.queryQuestionnairesCreatedByUser(the_user.getId()).size()==0){//查询当前用户创建的所有问卷
                    //删除用户
                    if(userService.deleteUser(user.getId())==1){
                        return Result.success(the_user.getId(), "删除用户成功");
                    }
                }else{
                    if(userService.queryChildrenCreatedByParent(the_user.getId()).size()!=0){
                        return Result.error("-2","删除用户失败,该用户存在关联数据,因为该用户下存在答者!");
                    }else if(groupService.queryGroupsCreatedByUser(the_user.getId()).size()!=0){
                        return Result.error("-2","删除用户失败,该用户存在关联数据,因为该用户下存在群组!");
                    }else if(questionnaireService.queryQuestionnairesCreatedByUser(the_user.getId()).size()!=0){
                        return Result.error("-2","删除用户失败,该用户存在关联数据,因为该用户下存在问卷!");
                    }
                }
                break;
            case 3:
                //如果该答者不属于任何一个群组、没有答过任何一个问卷，即该答者无数据关联，则允许将其删除
                if(groupService.queryGroupsBelongToAnswerer(the_user.getId()).size()==0&&//查询当前答者所属的所有群组
                   questionAnsweredService.queryQuestionnaireAnsweredBelongToAnswerer(the_user.getId()).size()==0){//查询当前答者拥有的所有答卷
                    //删除答者
                    if(userService.deleteUser(user.getId())==1){
                        return Result.success(the_user.getId(), "删除答者成功");
                    }
                }else{
                    if(groupService.queryGroupsBelongToAnswerer(the_user.getId()).size()!=0){
                        return Result.error("-3","删除答者失败,该答者存在关联数据,因为该答者属于某群组!");
                    }else if(questionAnsweredService.queryQuestionnaireAnsweredBelongToAnswerer(the_user.getId()).size()!=0){
                        return Result.error("-3","删除答者失败,该答者存在关联数据,因为该答者下存在答卷!");
                    }
                }
                break;
            default:
                break;
        }
        return Result.error("-4","无法删除此管理员!");
    }

    /**
     * 物理删除用户
     * @param user
     * 所必须的参数为 id 属性
     * @return 结果相关信息
     */
    @PostMapping("/pscDeleteUser")
    public Result<?> pscDeleteUser(@RequestBody User user){
        User the_user = userService.searchUserById(user.getId());
        if(the_user==null){
            return Result.error("0","不存在此用户id!");
        }
        if(userService.pscDeleteUser(user.getId())==1){
            return Result.success(user.getId(), "删除用户成功");
        }
        return Result.error("-1","删除用户失败!");
    }

    /**
     * 修改用户信息
     * @param user
     * 所必须的参数为 id 属性
     * @return 结果相关信息
     */
    @PostMapping("/updateUser")
    public Result<?> updateUser(@RequestBody User user){
        User the_user = userService.searchUserById(user.getId());
        if(the_user==null){
            return Result.error("0","不存在此用户id!");
        }
        if(userService.updateUser(user)==1){
            return Result.success(user, "修改用户信息成功");
        }
        return Result.error("-1","修改用户信息失败!");
    }

    /**
     * 模糊搜索用户
     * @param user
     * 所必须的参数为 identity 身份属性和 username 用户名属性
     * @return List<User> 用户列表
     */
    @PostMapping("/searchUser")
    public Result<?> searchUser(@RequestBody User user){
        List<User> userList = userService.searchUser(user.getUsername(),user.getIdentity());
        if(!userList.isEmpty()){
            return Result.success(userList, "查找用户成功");
        }
        return Result.error("-1","无相关用户！");
    }

    /**
     * 精准搜索用户——根据用户名
     * @param user
     * 所必须的参数为 username 用户名属性
     * @return User实体
     */
    @PostMapping("/findUser")
    public Result<?> findUser(@RequestBody User user){
        User userFind = userService.findUser(user.getUsername());
        if(userFind!=null){
            return Result.success(userFind, "查找用户成功");
        }
        return Result.error("-1","无此用户！");
    }

    /**
     * 精准搜索用户——根据用户id
     * @param user
     * 所必须的参数为 id 属性
     * @return User实体
     */
    @PostMapping("/searchUserById")
    public Result<?> searchUserById(@RequestBody User user){
        User userSearch = userService.searchUserById(user.getId());
        if(userSearch!=null){
            return Result.success(userSearch, "查找用户成功");
        }
        return Result.error("-1","无此用户！");
    }

    /**
     * 管理员查询所有租户的费用情况
     * @param admin
     * 所必须的参数为 username 管理员的用户名
     * @return Map(key:租户, value:该租户所对应的费用)
     */
    @PostMapping("/calculateCost")
    public Result<?> calculateCost(@RequestBody User admin){
        //在查询租户费用之前，需要先判断当前账号是否为管理员账号
        if(userService.findUser(admin.getUsername())==null||userService.findUser(admin.getUsername()).getIdentity()!=0){
            return Result.error("-1","不存在此管理员！");
        }else{
            Map<User,String> map = userService.calculateCost();
            List<Map<String,String>> tenantList = new ArrayList<>();//存储租户列表
            for(User theTenant : map.keySet()){
                //将答者相关信息存入其中
                Map<String,String> tenant = new HashMap<>();//存储某一个租户的各项信息
                tenant.put("id",theTenant.getId());
                tenant.put("username",theTenant.getUsername());
                tenant.put("password",theTenant.getPassword());
                tenant.put("phone",theTenant.getPhone());
                tenant.put("age",theTenant.getAge()+"");
                tenant.put("profession",theTenant.getProfession());
                tenant.put("institution",theTenant.getInstitution());
                tenant.put("identity",theTenant.getIdentity()+"");
                tenant.put("status",theTenant.getStatus());
                tenant.put("created_by",theTenant.getCreated_by());
                tenant.put("creation_date",theTenant.getCreation_date()+"");
                tenant.put("last_updated_by",theTenant.getLast_updated_by());
                tenant.put("last_update_date",theTenant.getLast_update_date()+"");
                tenant.put("is_deleted",theTenant.getIs_deleted()+"");
                tenant.put("parent_id",theTenant.getParent_id());
                tenant.put("questionnaire_count",theTenant.getQuestionnaire_count());
                tenant.put("cost",map.get(theTenant));
                tenantList.add(tenant);
            }
            if(tenantList.size()!=0){
                return Result.success(tenantList,"查询费用成功！");
            }else{
                return Result.error("-2","租户数量为0！");
            }
        }
    }

    /**
     * 批量导入用户
     * @param userList 信息尽可能完整
     * @return 最终成功导入的用户数量
     */
    @PostMapping("/batch")
    public Result<?> saveUserListByBatch(@RequestBody List<User> userList){
        int num_success = 0;//成功导入的用户数量，因为存在一些用户的用户名或手机号在数据库中已经存在，则这些用户不能被导入
        for (User user : userList) {
            List<User> userList1 = loginService.searchUserByUsername(user);//检测用户所填用户名是否已被使用，返回相同用户名的用户
            if (!userList1.isEmpty()) continue;
            List<User> userList2 = loginService.phoneUser(user);//检测用户所填手机号是否已被使用，返回相同手机号的用户
            if (!userList2.isEmpty()) continue;
            userService.addUser(user);//当用户的用户名和手机号在数据库中均不存在，则向数据库中添加该用户
            num_success++;
        }
        if(num_success==0){
            return Result.error("-1","所传入数据中，所有的用户名或手机号都已经存在！");
        }
        return Result.success(num_success,"批量导入成功");
    }

    /**
     * 查询当前租户创建的所有用户——根据当前租户id
     * @param tenant 租户实体
     * 所必须的参数为 id 租户的id
     * @return 结果相关信息和 List<User> 租户创建的所有用户
     */
    @PostMapping("/queryUsersCreatedByTenant")
    public Result<?> queryUsersCreatedByTenant(@RequestBody User tenant){
        User the_tenant = userService.searchUserById(tenant.getId());
        if(the_tenant==null){
            return Result.error("0","不存在此用户id!");
        }
        if(the_tenant.getIdentity()==1){//辨别用户身份是否为租户
            List<User> userList = userService.queryChildrenCreatedByParent(the_tenant.getId());//查询当前租户创建的用户
            if(userList!=null){
                return Result.success(userList,"查询成功！");
            }else{
                return Result.error("-1","该租户下不存在用户！");
            }
        }else {
            return Result.error("-2","该用户不是租户！");
        }
    }

    /**
     * 查询当前用户创建的所有答者——根据当前用户id
     * @param user 用户实体
     * 所必须的参数为 id 用户的id
     * @return 结果相关信息和 List<User> 用户创建的所有答者
     */
    @PostMapping("/queryAnswersCreatedByUser")
    public Result<?> queryAnswersCreatedByUser(@RequestBody User user){
        User the_user = userService.searchUserById(user.getId());
        if(the_user==null){
            return Result.error("0","不存在此用户id!");
        }
        if(the_user.getIdentity()==2){//辨别用户身份是否为用户
            List<User> answerList = userService.queryChildrenCreatedByParent(the_user.getId());//查询当前用户创建的答者
            if(answerList.size()!=0){
                return Result.success(answerList,"查询成功！");
            }else{
                return Result.error("-1","该用户下不存在答者！");
            }
        }else {
            return Result.error("-2","该用户不是用户！");
        }
    }
}
